package com.training.web.service;

import com.training.bean.Audio;
import com.training.bean.Course;
import com.training.bean.CourseContent;
import com.training.bean.CourseStage;
import com.training.web.repository.WebAudioRepository;
import com.training.web.repository.WebCourseContentRepository;
import com.training.api.repository.CourseContentRepository;
import com.training.api.repository.CourseRepository;
import com.training.api.repository.CourseStageRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;
import java.util.Optional;

@Service
public class WebAudioService {
    @Autowired
    private WebAudioRepository repository;
    
    @Autowired
    private WebCourseContentRepository courseContentRepository;
    
    @Autowired
    private CourseContentRepository contentRepository;
    
    @Autowired
    private CourseRepository courseRepository;
    
    @Autowired
    private CourseStageRepository courseStageRepository;
    
    public List<Audio> getAllAudios(int ccid) {
        return repository.findAllByCourseContentId(ccid);
    }
    
    public Audio getAudioById(int id) {
        Optional<Audio> audio = repository.findById(id);
        return audio.orElse(null);
    }
    
    public Audio addAudio(Audio audio) {
        // 设置创建和更新时间
        Date now = new Date();
        audio.setCreate_date(now);
        audio.setUpdata_date(now);
        
        // 保存并返回保存后的对象
        Audio savedAudio = repository.save(audio);
        
        // 更新关联的课程内容的总时长
        updateCourseContentDuration(audio.getCcid());
        
        return savedAudio;
    }
    
    public Audio updateAudio(Audio audio) {
        // 更新更新时间
        audio.setUpdata_date(new Date());
        
        // 保存并返回保存后的对象
        Audio savedAudio = repository.save(audio);
        
        // 更新关联的课程内容的总时长
        updateCourseContentDuration(audio.getCcid());
        
        return savedAudio;
    }
    
    public void deleteAudio(int id) {
        // 先获取要删除的音频对象以获取ccid
        Audio audio = getAudioById(id);
        int ccid = audio != null ? audio.getCcid() : -1;
        
        repository.deleteById(id);
        
        // 如果音频存在，更新关联的课程内容的总时长
        if (ccid > 0) {
            updateCourseContentDuration(ccid);
        }
    }
    
    /**
     * 更新课程内容的总时长
     * @param ccid 课程内容ID
     */
    private void updateCourseContentDuration(int ccid) {
        // 获取该课程内容下的所有音频
        List<Audio> audios = repository.findAllByCourseContentId(ccid);
        
        // 获取其中一个音频的时长作为课程内容的时长（所有音频时长相同）
        long duration = 0;
        if (!audios.isEmpty()) {
            duration = audios.get(0).getDuration();
        }
        
        // 更新课程内容的时长
        Optional<CourseContent> courseContentOpt = courseContentRepository.findById(ccid);
        if (courseContentOpt.isPresent()) {
            CourseContent courseContent = courseContentOpt.get();
            courseContent.setDuration(duration);
            courseContent.setUpdata_date(new Date());
            courseContentRepository.save(courseContent);
            
            // 同时更新所属课程的总时长
            updateCourseDuration(courseContent.getCid());
        }
    }
    
    /**
     * 更新课程的总时长
     * @param courseId 课程ID
     */
    private void updateCourseDuration(int courseId) {
        // 获取该课程下的所有课程内容
        List<CourseContent> contents = contentRepository.findCourseContentByCId(courseId);
        
        // 计算总时长
        long totalDuration = contents.stream()
                .mapToLong(CourseContent::getDuration)
                .sum();
        
        // 更新课程的时长
        Optional<Course> courseOpt = courseRepository.findById(courseId);
        if (courseOpt.isPresent()) {
            Course course = courseOpt.get();
            course.setDuration(totalDuration);
            course.setUpdata_date(new Date());
            courseRepository.save(course);
            
            // 同时更新所属课程阶段的总时长
            updateCourseStageDuration(course.getCsid());
        }
    }
    
    /**
     * 更新课程阶段的总时长
     * @param courseStageId 课程阶段ID
     */
    private void updateCourseStageDuration(int courseStageId) {
        // 获取该课程阶段下的所有课程
        List<Course> courses = courseRepository.findCourseByCSId(courseStageId);
        
        // 计算总时长
        long totalDuration = courses.stream()
                .mapToLong(Course::getDuration)
                .sum();
        
        // 更新课程阶段的时长
        Optional<CourseStage> courseStageOpt = courseStageRepository.findById(courseStageId);
        if (courseStageOpt.isPresent()) {
            CourseStage courseStage = courseStageOpt.get();
            courseStage.setDuration(totalDuration);
            courseStage.setUpdata_date(new Date());
            courseStageRepository.save(courseStage);
        }
    }
}